#pragma once
#include <iostream>
#include <string>
#include <unordered_map>
#include <cstring>
#include <cerrno>
#include <cassert>
#include <signal.h>
#include <unistd.h>
#include <memory>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/wait.h>
#include <pthread.h>
#include <ctype.h>
#include "ThreadPool/log.hpp"
#include "ThreadPool/threadPool.hpp"
#include "ThreadPool/Task.hpp"


static void dictOnline(int sock, const std::string &clientip,
                   const uint16_t &clientport, const std::string &thread_name)
{
    char buffer[1024];
    static std::unordered_map<std::string, std::string> dict = {
        {"apple", "苹果"},
        {"banana", "香蕉"},
    };
    // read && write 可以直接被使用 
    ssize_t s = recv(sock, buffer, sizeof(buffer) - 1,0);
    if (s > 0)
    {
        buffer[s] = 0;                  // 将发过来的数据当做字符串
        std::cout << thread_name << "|" << clientip << ":" << clientport << "# " << buffer << std::endl;
        std::string message;
        auto iter = dict.find(buffer);
        if(iter == dict.end()) 
            message = "我不知道...";
        else 
            message = iter->second;
        send(sock, message.c_str(), message.size(),0);
    }
    else if (s == 0) // 对端关闭连接
    {
        logMessage(NORMAL, "%s:%d shutdown, me too!", clientip.c_str(), clientport);
    }
    else
    { //
        logMessage(ERROR, "read socket error, %d:%s", errno, strerror(errno));
    }
    close(sock); //处理完业务，关闭socket
}

//封装tcp服务器类
class TcpServer
{
private:
    const static int gbacklog = 20; //是listen的第二个参数，表示全链接队列的长度
public:
    TcpServer(uint16_t port, std::string ip = "0.0.0.0")
        : _listensock(-1), _port(port),
          _ip(ip), _threadpool_ptr(ThreadPool<Task>::getThreadPool())
    {
    }
    //初始化服务器
    void initServer()
    {
        // 1. 创建socket 
        _listensock = socket(AF_INET, SOCK_STREAM, 0);
        // AF_INET表示网络通信，跟UDP的区别是SOCK_STREAM是面向字节流的，表示TCP通信
        if (_listensock < 0)
        {
            //创建失败，打印日志信息
            logMessage(FATAL, "create socket error, %d:%s", errno, strerror(errno));
            exit(2);
        }
        //创建成功，打印日志信息
        logMessage(NORMAL, "create socket success, listensock: %d", _listensock); // 3

        // 2. bind 
        struct sockaddr_in local;           //定义sockaddr_in结构体
        memset(&local, 0, sizeof local);    //初始化sockaddr_in结构体
        local.sin_family = AF_INET;         //通信方式为网络
        local.sin_port = htons(_port);      //主机序列端口号转为网络序列
        inet_pton(AF_INET, _ip.c_str(), &local.sin_addr);//将ip地址从字符串格式转换为网络地址形式
       
        //bind
        //bind失败输出错误信息
        if (bind(_listensock, (struct sockaddr *)&local, sizeof(local)) < 0)
        {
            logMessage(FATAL, "bind error, %d:%s", errno, strerror(errno));
            exit(3);
        }

        // 3. 因为TCP是面向连接的，当我们正式通信的时候，需要先建立连接
        // 将套接字状态设置为监听状态
        if (listen(_listensock, gbacklog) < 0)
        {
            logMessage(FATAL, "listen error, %d:%s", errno, strerror(errno));
            exit(4);
        }

        //listen成功，服务器初始化成功
        logMessage(NORMAL, "init server success");
    }

    //启动服务器
    void start()
    {
        _threadpool_ptr->run();     //启动线程池
        while (true)
        {
            // 4. 获取连接
            struct sockaddr_in src;
            socklen_t len = sizeof(src);
            //accept获取新连接，跟rsvfrom的参数类似，成功返回一个新的socket(服务套接字)，失败返回-1
            int servicesock = accept(_listensock, (struct sockaddr*)&src, &len);
            // _listensock(取新连接)------servicesock(提供服务)
            if (servicesock < 0)
            {
                logMessage(ERROR, "accept error, %d:%s", errno, strerror(errno));
                continue;//继续获取连接
            }
            // 获取连接成功了，双方已经建立连接了，开始进行通信服务
            uint16_t client_port = ntohs(src.sin_port); //拿到客户端的端口号
            std::string client_ip = inet_ntoa(src.sin_addr);//拿到客户端的ip
            // 输出客户端的端口号和ip的日志信息
            logMessage(NORMAL, "link success, servicesock: %d | %s : %d |\n",
                       servicesock, client_ip.c_str(), client_port);
            //使用线程池处理业务逻辑         
            Task t(servicesock, client_ip, client_port, dictOnline);
            _threadpool_ptr->pushTask(t);
        }
    }
    ~TcpServer() {}

private:
    uint16_t _port;                                     //声明端口号
    std::string _ip;                                    //声明ip
    int _listensock;                                    //声明监听套接字
    std::unique_ptr<ThreadPool<Task>> _threadpool_ptr;  //声明线程池的对象的指针
};
